// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef CONTENT_RENDERER_PEPPER_PEPPER_TRY_CATCH_H_
#define CONTENT_RENDERER_PEPPER_PEPPER_TRY_CATCH_H_

#include "base/macros.h"
#include "base/memory/ref_counted.h"
#include "content/common/content_export.h"
#include "ppapi/c/pp_var.h"
#include "ppapi/shared_impl/scoped_pp_var.h"
#include "v8/include/v8.h"

namespace content {

class PepperPluginInstanceImpl;
class V8VarConverter;

// Base class for scripting TryCatch helpers.
class CONTENT_EXPORT PepperTryCatch {
public:
    // PepperTryCatch objects should only be used as stack variables. This object
    // takes a reference on the given PepperPluginInstanceImpl.
    PepperTryCatch(PepperPluginInstanceImpl* instance,
        V8VarConverter* var_converter);
    virtual ~PepperTryCatch();

    virtual void SetException(const char* message) = 0;
    virtual bool HasException() = 0;
    // Gets the context to execute scripts in.
    virtual v8::Local<v8::Context> GetContext() = 0;

    // Convenience functions for doing conversions to/from V8 values and sets an
    // exception if there is an error in the conversion.
    v8::Local<v8::Value> ToV8(PP_Var var);
    ppapi::ScopedPPVar FromV8(v8::Local<v8::Value> v8_value);

protected:
    // Make sure that |instance_| is alive for the lifetime of PepperTryCatch.
    // PepperTryCatch is used mostly in Pepper scripting code, where it can be
    // possible to enter JavaScript synchronously which can cause the plugin to
    // be deleted.
    //
    // Note that PepperTryCatch objects should only ever be on the stack, so this
    // shouldn't keep the instance around for too long.
    scoped_refptr<PepperPluginInstanceImpl> instance_;

    V8VarConverter* var_converter_;
};

// Catches var exceptions and emits a v8 exception.
class PepperTryCatchV8 : public PepperTryCatch {
public:
    PepperTryCatchV8(PepperPluginInstanceImpl* instance,
        V8VarConverter* var_converter,
        v8::Isolate* isolate);
    ~PepperTryCatchV8() override;

    bool ThrowException();
    void ThrowException(const char* message);
    PP_Var* exception() { return &exception_; }

    // PepperTryCatch
    void SetException(const char* message) override;
    bool HasException() override;
    v8::Local<v8::Context> GetContext() override;

private:
    PP_Var exception_;

    DISALLOW_COPY_AND_ASSIGN(PepperTryCatchV8);
};

// Catches v8 exceptions and emits a var exception.
class PepperTryCatchVar : public PepperTryCatch {
public:
    // The PP_Var exception will be placed in |exception|. The user of this class
    // is responsible for managing the lifetime of the exception. It is valid to
    //  pass NULL for |exception| in which case no exception will be set.
    PepperTryCatchVar(PepperPluginInstanceImpl* instance,
        V8VarConverter* var_converter,
        PP_Var* exception);
    ~PepperTryCatchVar() override;

    // PepperTryCatch
    void SetException(const char* message) override;
    bool HasException() override;
    v8::Local<v8::Context> GetContext() override;

private:
    // Code which uses PepperTryCatchVar doesn't typically have a HandleScope,
    // make one for them. Note that this class is always allocated on the stack.
    v8::HandleScope handle_scope_;

    v8::Local<v8::Context> context_;

    v8::TryCatch try_catch_;

    PP_Var* exception_;
    bool exception_is_set_;

    DISALLOW_COPY_AND_ASSIGN(PepperTryCatchVar);
};

} // namespace content

#endif // CONTENT_RENDERER_PEPPER_PEPPER_TRY_CATCH_H_
